package info.qingshui.browser.hk;

import info.qingshui.browser.R;
import java.text.*;
import java.util.*;

/**
 * 字符串处理工具集
 * 全部为静态方法
 *
 */
public class StringUtil 
{
	/**
	 * 将字符串转为WML编码,用于wml页面显示
	 * @param str 
	 * @return String
	 */
	public static String encodeWML(String str)
	{
		if(str == null)
		{
			return "";
		}
		// 不用正则表达式替换，直接通过循环，节省cpu时间
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < str.length(); ++i)
		{
			char c = str.charAt(i);
			switch(c)
			{
				case '\u00FF':
				case '\u0024':
					break;
				case '&':
					sb.append("&amp;");
					break;
				case '\t':
					sb.append("  ");
					break;
				case '<':
					sb.append("&lt;");
					break;
				case '>':
					sb.append("&gt;");
					break;
				case '\"':
					sb.append("&quot;");
					break;
				case '\n':
					sb.append("<br/>");
					break;
				default:
					if(c >= '\u0000' && c <= '\u001F')
						continue;
					sb.append(c);
					break;
			}
		}
		return sb.toString();
	}
	
	/**
	 * 过滤SQL字符串,防止SQL inject
	 * @param sql
	 * @return String
	 */
	public static String encodeSQL(String sql)
	{
		if (sql == null)
		{
			return "";
		}
		// 不用正则表达式替换，直接通过循环，节省cpu时间
		StringBuilder sb = new StringBuilder();
		for(int i = 0; i < sql.length(); ++i)
		{
			char c = sql.charAt(i);
			switch(c)
			{
			case '\\':
				sb.append("\\\\");
				break;
			case '\r':
				sb.append("\\r");
				break;
			case '\n':
				sb.append("\\n");
				break;
			case '\t':
				sb.append("\\t");
				break;
			case '\b':
				sb.append("\\b");
				break;
			case '\'':
				sb.append("\\\'");
				break;
			case '\"':
				sb.append("\\\"");
				break;
			default:
				sb.append(c);
			}
		}
		return sb.toString();
	}
	
	/**
	 * 删除在wml下不能正确处理的字符
	 * @param str	要处理的字符串
	 * @return		结果
	 */
	public static String removeInvalidWML(String str){
    	if(str == null)
    		return null;
    	//* 不用正则表达式替换，直接通过循环，节省cpu时间
    	StringBuilder sb = new StringBuilder();
		for(int i = 0; i < str.length(); ++i)
		{
			char c = str.charAt(i);
			if(c >= '\u0000' && c <= '\u001F')
				continue;
			switch(c)
			{
			case '\u00FF':
			case '\u0024':
				break;
			case '&':
				sb.append("&amp;");
				break;
			case '\t':
				sb.append("  ");
				break;
			case '<':
				sb.append("&lt;");
				break;
			case '>':
				sb.append("&gt;");
				break;
			case '\"':
				sb.append("&quot;");
				break;
			case '^':
			case '`':
				break;
			default:
				sb.append(c);
				break;
			}
		}
		return sb.toString();
	}
	
	/**
	 * 格式化日期
	 * 
	 * @param dateStr
	 *            输入的日期字符串
	 * @param inputFormat
	 *            输入日期格式
	 * @param format
	 *            输出日期格式
	 * @return String 格式化后的日期,如果不能格式化则输出原日期字符串
	 */
	public static String formatDate(String dateStr, String inputFormat, String format)
	{
		String resultStr = dateStr;
		try 
		{
			Date date = new SimpleDateFormat(inputFormat).parse(dateStr);
			resultStr = formatDate(date,format);
		}
		catch (ParseException e) 
		{
		}	
		return resultStr;		
	}
	/**
	 * 格式化日期
	 * 输入日期格式只支持yyyy-MM-dd HH:mm:ss 或 yyyy/MM/dd HH:mm:ss
	 * @param dateStr 输入的日期字符串
	 * @param format 输出日期格式
	 * @return String 格式化后的日期,如果不能格式化则输出原日期字符串
	 */	
	public static String formatDate(String dateStr, String format)
	{
		String resultStr = dateStr;
		String inputFormat = "yyyy-MM-dd HH:mm:ss";
		if(dateStr == null)
		{
			return "";
		}
		if(dateStr.matches("\\d{1,4}\\-\\d{1,2}\\-\\d{1,2}\\s+\\d{1,2}:\\d{1,2}:\\d{1,2}\\.\\d{1,3}"))
		{
			inputFormat = "yyyy-MM-dd HH:mm:ss.SSS";
		}
		else if(dateStr.matches("\\d{4}\\-\\d{1,2}\\-\\d{1,2} +\\d{1,2}:\\d{1,2}"))
		{
			inputFormat = "yyyy-MM-dd HH:mm:ss";
		}
		else if(dateStr.matches("\\d{4}\\-\\d{1,2}\\-\\d{1,2} +\\d{1,2}:\\d{1,2}"))
		{
			inputFormat = "yyyy-MM-dd HH:mm";
		}
		else if(dateStr.matches("\\d{4}\\-\\d{1,2}\\-\\d{1,2} +\\d{1,2}"))
		{
			inputFormat = "yyyy-MM-dd HH";
		}
		else if(dateStr.matches("\\d{4}\\-\\d{1,2}\\-\\d{1,2} +\\d{1,2}"))
		{
			inputFormat = "yyyy-MM-dd";
		}
		else if(dateStr.matches("\\d{1,4}/\\d{1,2}/\\d{1,2}\\s+\\d{1,2}:\\d{1,2}:\\d{1,2}\\.\\d{1,3}"))
		{
			inputFormat = "yyyy/MM/dd HH:mm:ss.SSS";
		}
		else if(dateStr.matches("\\d{4}/\\d{1,2}/\\d{1,2} +\\d{1,2}:\\d{1,2}"))
		{
			inputFormat = "yyyy/MM/dd HH:mm:ss";
		}
		else if(dateStr.matches("\\d{4}/\\d{1,2}/\\d{1,2} +\\d{1,2}:\\d{1,2}"))
		{
			inputFormat = "yyyy/MM/dd HH:mm";
		}
		else if(dateStr.matches("\\d{4}/\\d{1,2}/\\d{1,2} +\\d{1,2}"))
		{
			inputFormat = "yyyy/MM/dd HH";
		}
		else if(dateStr.matches("\\d{4}/\\d{1,2}/\\d{1,2} +\\d{1,2}"))
		{
			inputFormat = "yyyy/MM/dd";
		}
		resultStr = formatDate(dateStr,inputFormat,format);
		return resultStr;
	}
	
	/**
	 * 格式化日期
	 * @param date 输入日期
	 * @param format 输出日期格式
	 * @return String
	 */
	public static String formatDate(Date date, String format)
	{
    	SimpleDateFormat sdf = new SimpleDateFormat(format);
    	return sdf.format(date);		
	}
	
    /**
     * 获取字符型参数，若输入字符串为null，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值 
     * @return 字符串参数
     */
    public static String convertString(String str, String defaults)
    {
        if(str == null)
        {
            return defaults;
        }
        else
        {
            return str;
        }
    }
        
    /**
     * 获取int参数，若输入字符串为null或不能转为int，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return int参数
     */
    public static int convertInt(String str, int defaults)
    {
        if(str == null)
        {
            return defaults;
        }        
        try
        {
            return Integer.parseInt(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 获取long型参数，若输入字符串为null或不能转为long，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return long参数
     */
    public static long convertLong(String str, long defaults)
    {
        if(str == null)
        {
            return defaults;
        }        
        try
        {
            return Long.parseLong(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 获取double型参数，若输入字符串为null或不能转为double，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return double型参数
     */
    public static double convertDouble(String str, double defaults)
    {
        if(str == null)
        {
            return defaults;
        }
        try
        {
            return Double.parseDouble(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 获取short型参数，若输入字符串为null或不能转为short，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return short型参数
     */
    public static short convertShort(String str, short defaults)
    {
        if(str == null)
        {
            return defaults;
        }
        try
        {
            return Short.parseShort(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 获取float型参数，若输入字符串为null或不能转为float，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return float型参数
     */
    public static float convertFloat(String str, float defaults)
    {
        if(str == null)
        {
            return defaults;
        }
        try
        {
            return Float.parseFloat(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 获取boolean型参数，若输入字符串为null或不能转为boolean，则返回设定的默认值
     * @param str 输入字符串
     * @param defaults 默认值
     * @return boolean型参数
     */
    public static boolean convertBoolean(String str, boolean defaults)
    {
        if(str == null)
        {
            return defaults;
        }
        try
        {
            return Boolean.parseBoolean(str);
        }
        catch(Exception e)
        {
            return defaults;
        }
    }
    
    /**
     * 分割字符串
     * @param line			原始字符串
     * @param seperator		分隔符
     * @return				分割结果
     */
    public static String[] split(String line, String seperator)
	{
		if(line == null || seperator == null || seperator.length() == 0)
			return null;
		ArrayList<String> list = new ArrayList<String>();
		int pos1 = 0;
		int pos2;
		for(; ; )
		{
			pos2 = line.indexOf(seperator, pos1);
			if(pos2 < 0)
			{
				list.add(line.substring(pos1));
				break;
			}
			list.add(line.substring(pos1, pos2));
			pos1 = pos2 + seperator.length();
		}
		// 去掉末尾的空串，和String.split行为保持一致
		for(int i = list.size() - 1; i >= 0 && list.get(i).length() == 0; --i)
		{
			list.remove(i);
		}
		return list.toArray(new String[0]);
	}
    
    /**
     * 分割字符串，并转换为int
     * @param line		原始字符串
     * @param seperator	分隔符
     * @param def		默认值
     * @return			分割结果
     */
    public static int[] splitInt(String line, String seperator, int def)
    {
    	String[] ss = split(line, seperator);
    	int[] r = new int[ss.length];
    	for(int i = 0; i < r.length; ++i)
    	{
    		r[i] = convertInt(ss[i], def);
    	}
    	return r;
    }
    
    /**
     * 字符串全量替换
     * @param s			原始字符串
     * @param src		要替换的字符串
     * @param dest		替换目标
     * @return			结果
     */
    public static String replaceAll(String s, String src, String dest)
    {
    	if(s == null || src == null || dest == null || src.length() == 0)
    		return s;
    	int pos = s.indexOf(src);			// 查找第一个替换的位置
    	if(pos < 0)
    		return s;
    	int capacity = dest.length() > src.length() ? s.length() * 2: s.length();
    	StringBuilder sb = new StringBuilder(capacity);
    	int writen = 0;
    	for(; pos >= 0; )
    	{
    		sb.append(s, writen, pos);		// append 原字符串不需替换部分
    		sb.append(dest);				// append 新字符串
    		writen = pos + src.length();	// 忽略原字符串需要替换部分
    		pos = s.indexOf(src, writen);	// 查找下一个替换位置
    	}
    	sb.append(s, writen, s.length());	// 替换剩下的原字符串
    	return sb.toString();
    }
    
    public static void main(String[] argv)
    {
    	String str = "http://m.singtao.com";
    	System.out.println("str length: " + str.length());
    	String r = null;
    	long b = System.currentTimeMillis();
    	for(int i = 0; i < 1; ++i)
    		//r = str.replaceAll(" cddd", "---");
    		r = replaceAll(str, "m.singtao.com", "8.p.rukou.mobi:1225");
    	//System.out.println(encodeWML(sql));
    	long e = System.currentTimeMillis();
    	System.out.println("result: " + r);
    	System.out.println("time: " + (e - b));
    }
}
